home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / OpenGL / stonehenge / main.c++ < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  11.6 KB  |  332 lines
  1. /*
  2.  * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
  3.  * ALL RIGHTS RESERVED
  4.  * Permission to use, copy, modify, and distribute this software for
  5.  * any purpose and without fee is hereby granted, provided that the above
  6.  * copyright notice appear in all copies and that both the copyright notice
  7.  * and this permission notice appear in supporting documentation, and that
  8.  * the name of Silicon Graphics, Inc. not be used in advertising
  9.  * or publicity pertaining to distribution of the software without specific,
  10.  * written prior permission.
  11.  *
  12.  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
  13.  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
  14.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
  15.  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
  16.  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
  17.  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
  18.  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
  19.  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
  20.  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
  21.  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
  22.  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  23.  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
  24.  *
  25.  * US Government Users Restricted Rights
  26.  * Use, duplication, or disclosure by the Government is subject to
  27.  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
  28.  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
  29.  * clause at DFARS 252.227-7013 and/or in similar or successor
  30.  * clauses in the FAR or the DOD or NASA FAR Supplement.
  31.  * Unpublished-- rights reserved under the copyright laws of the
  32.  * United States.  Contractor/manufacturer is Silicon Graphics,
  33.  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
  34.  *
  35.  * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
  36.  */
  37. #include <GL/glu.h>
  38. #include <GL/glx.h>
  39.  
  40. #include <X11/Intrinsic.h>
  41. #include <Xm/Xm.h>
  42. #include <Xm/CascadeB.h>
  43. #include <Xm/Frame.h>
  44. #include <Xm/MainW.h>
  45. #include <Xm/PushB.h>
  46. #include <Xm/PushBG.h>
  47. #include <Xm/RowColumn.h>
  48. #include <Xm/ToggleB.h>
  49. #include <GLwMDrawA.h>
  50.  
  51. #include <stdio.h>
  52. #include <stdlib.h>
  53.  
  54. #include "atmosphere.h"
  55. #include "scene.h"
  56. #include "callbacks.h"
  57.  
  58. static Display *display;
  59. XtAppContext app_context;
  60. Widget glw;
  61.  
  62. const int max_args = 20;
  63.  
  64. XVisualInfo *find_visual() 
  65. {
  66.   int attr[256], i, stencil, dbuffer, accum;
  67.   XVisualInfo *vi;
  68.  
  69.   i = 0;
  70.   attr[i++] = GLX_RGBA;
  71.   attr[i++] = GLX_RED_SIZE;  attr[i++] = 1;
  72.   attr[i++] = GLX_GREEN_SIZE;  attr[i++] = 1;
  73.   attr[i++] = GLX_BLUE_SIZE;  attr[i++] = 1;
  74.   attr[i++] = GLX_DEPTH_SIZE;  attr[i++] = 1;
  75.   dbuffer = i;
  76.   attr[i++] = GLX_DOUBLEBUFFER;
  77.   stencil = i;
  78.   attr[i++] = GLX_STENCIL_SIZE;
  79.   attr[i++] = 1;
  80.   accum = i;
  81.   attr[i++] = GLX_ACCUM_RED_SIZE;  attr[i++] = 1;
  82.   attr[i++] = GLX_ACCUM_BLUE_SIZE;  attr[i++] = 1;
  83.   attr[i++] = GLX_ACCUM_GREEN_SIZE;  attr[i++] = 1;
  84.   attr[i++] = GLX_ACCUM_ALPHA_SIZE;  attr[i++] = 1;
  85.   attr[i++] = (int)None;
  86.  
  87.   vi = glXChooseVisual(display, DefaultScreen(display), attr);
  88.   if (vi == NULL) {
  89.     fprintf(stderr, "Unable to find visual with accumulation buffer.\n");
  90.     fprintf(stderr, "(Fancy fog won't work).\n");
  91.     attr[accum] = (int)None;
  92.     vi = glXChooseVisual(display, DefaultScreen(display), attr);
  93.     if (vi == NULL) {
  94.       fprintf(stderr, "Unable to find visual with stencil buffer.\n");
  95.       fprintf(stderr, "(Things won't look quite as good).\n");
  96.       attr[stencil] = (int)None;
  97.       vi = glXChooseVisual(display, DefaultScreen(display), attr);
  98.       if (vi == NULL) {
  99.     fprintf(stderr, "Unable to find double-buffered visual.\n");
  100.     fprintf(stderr, "(Things will look even worse).\n");
  101.     attr[dbuffer] = (int)None;
  102.     vi = glXChooseVisual(display, DefaultScreen(display), attr);
  103.     if (vi == NULL) fprintf(stderr, "Can't find visual at all.\n");
  104.       }
  105.     }
  106.   }
  107.   return vi;
  108. }
  109.  
  110. Widget create_widgets(Widget parent)
  111. {
  112.   Widget main_window;
  113.   Widget menu_bar;
  114.   Widget menu_pane; 
  115.   Widget button;
  116.   Widget cascade;
  117.   Widget frame;
  118.   XVisualInfo *vi;
  119.  
  120.   Arg args[max_args];
  121.   int argcount;
  122.  
  123.   char buffer[128];
  124.  
  125.   int i;
  126.  
  127.   main_window = XmCreateMainWindow(parent, "main1", NULL, 0);
  128.   XtManageChild(main_window);
  129.  
  130.   menu_bar = XmCreateMenuBar(main_window, "menu_bar", NULL, 0);
  131.   XtManageChild(menu_bar);
  132.     
  133.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  134.   button = XmCreatePushButton(menu_pane, "Exit", NULL, 0);
  135.   XtManageChild(button);
  136.   XtAddCallback(button, XmNactivateCallback, (XtCallbackProc)exitCB, NULL);
  137.       
  138.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  139.   cascade = XmCreateCascadeButton(menu_bar, "File", args, 1);
  140.   XtManageChild(cascade);
  141.  
  142.  
  143.  
  144.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  145.   XtSetArg(args[0], XmNset, use_lighting);
  146.   button = XmCreateToggleButton(menu_pane, "Lighting", args, 1);
  147.   XtManageChild(button);
  148.   XtAddCallback(button, XmNvalueChangedCallback, 
  149.                 (XtCallbackProc)intToggleCB, &use_lighting);
  150.   XtSetArg(args[0], XmNset, draw_shadows);
  151.   button = XmCreateToggleButton(menu_pane, "Shadows", args, 1);
  152.   XtManageChild(button);
  153.   XtAddCallback(button, XmNvalueChangedCallback, 
  154.                 (XtCallbackProc)intToggleCB, &draw_shadows);
  155.  
  156.  
  157.   XtSetArg(args[0], XmNset, use_normal_fog);
  158.   button = XmCreateToggleButton(menu_pane, "Fog", args, 1);
  159.   XtManageChild(button);
  160.   XtAddCallback(button, XmNvalueChangedCallback, 
  161.                 (XtCallbackProc)intToggleCB, &use_normal_fog);
  162.  
  163. #ifdef TEXTURE
  164.   XtSetArg(args[0], XmNset, use_textures);
  165.   button = XmCreateToggleButton(menu_pane, "Texture Map", args, 1);
  166.   XtManageChild(button);
  167.   XtAddCallback(button, XmNvalueChangedCallback, 
  168.                 (XtCallbackProc)intToggleCB, &use_textures);
  169. #endif
  170.  
  171.   XtSetArg(args[0], XmNset, use_telescope);
  172.   button = XmCreateToggleButton(menu_pane, "Telescope", args, 1);
  173.   XtManageChild(button);
  174.   XtAddCallback(button, XmNvalueChangedCallback,
  175.         (XtCallbackProc)intToggleCB, &use_telescope);
  176.  
  177.   XtSetArg(args[0], XmNset, use_antialias);
  178.   button = XmCreateToggleButton(menu_pane, "Antialias", args, 1);
  179.   XtManageChild(button);
  180.   XtAddCallback(button, XmNvalueChangedCallback,
  181.         (XtCallbackProc)intToggleCB, &use_antialias);
  182.  
  183.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  184.   cascade = XmCreateCascadeButton(menu_bar, "SPFX", args, 1);
  185.   XtManageChild(cascade);
  186.  
  187.  
  188.   argcount = 0;
  189.   XtSetArg(args[argcount], XmNradioBehavior, True); argcount++;
  190.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args, argcount);
  191.   XtSetArg(args[0], XmNset, TRUE);
  192.   for (i = 0; i < nweathers; i++) {
  193.     if (i == def_weather_index) argcount = 1;
  194.     else argcount = 0;
  195.     button = XmCreateToggleButton(menu_pane, (char *)weathers[i].name, 
  196.                   args, argcount);
  197.     XtManageChild(button);
  198.     XtAddCallback(button, XmNvalueChangedCallback, 
  199.           (XtCallbackProc)weatherCB,
  200.           (XtPointer)(&weathers[i]));
  201.   }
  202.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  203.   cascade = XmCreateCascadeButton(menu_bar, "Weather", args, 1);
  204.   XtManageChild(cascade);
  205.  
  206.  
  207.   argcount = 0;
  208.   XtSetArg(args[argcount], XmNradioBehavior, True); argcount++;
  209.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args, argcount);
  210.   button = XmCreatePushButton(menu_pane, "Current Time", NULL, 0);
  211.   XtManageChild(button);
  212.   XtAddCallback(button, XmNactivateCallback, 
  213.         (XtCallbackProc)currentTimeCB, NULL);
  214.   button = XmCreatePushButton(menu_pane, "10 a.m.", NULL, 0);
  215.   XtManageChild(button);
  216.   XtAddCallback(button, XmNactivateCallback, 
  217.         (XtCallbackProc)time10amCB, NULL);
  218.   button = XmCreatePushButton(menu_pane, "Noon", NULL, 0);
  219.   XtManageChild(button);
  220.   XtAddCallback(button, XmNactivateCallback, 
  221.         (XtCallbackProc)time12pmCB, NULL);
  222.   button = XmCreatePushButton(menu_pane, "4 p.m.", NULL, 0);
  223.   XtManageChild(button);
  224.   XtAddCallback(button, XmNactivateCallback, 
  225.         (XtCallbackProc)time4pmCB, NULL);
  226.  
  227.   XtSetArg(args[0], XmNset, 1); argcount = 1;
  228.   button = XmCreateToggleButton(menu_pane, "Hold Time", args, 1);
  229.   XtManageChild(button);
  230.   XtAddCallback(button, XmNvalueChangedCallback,
  231.         (XtCallbackProc)timeSpeedCB, (XtPointer)0);
  232.   button = XmCreateToggleButton(menu_pane, "Scale = 1:1", NULL, 0);
  233.   XtManageChild(button);
  234.   XtAddCallback(button, XmNvalueChangedCallback,
  235.         (XtCallbackProc)timeSpeedCB, (XtPointer)1);
  236.   button = XmCreateToggleButton(menu_pane, "Scane = 1:10", NULL, 0);
  237.   XtManageChild(button);
  238.   XtAddCallback(button, XmNvalueChangedCallback,
  239.         (XtCallbackProc)timeSpeedCB, (XtPointer)10);
  240.   button = XmCreateToggleButton(menu_pane, "Scane = 1:100", NULL, 0);
  241.   XtManageChild(button);
  242.   XtAddCallback(button, XmNvalueChangedCallback,
  243.         (XtCallbackProc)timeSpeedCB, (XtPointer)100);
  244.   button = XmCreateToggleButton(menu_pane, "Scane = 1:500", NULL, 0);
  245.   XtManageChild(button);
  246.   XtAddCallback(button, XmNvalueChangedCallback,
  247.         (XtCallbackProc)timeSpeedCB, (XtPointer)500);  
  248.  
  249.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  250.   cascade = XmCreateCascadeButton(menu_bar, "Time", args, 1);
  251.   XtManageChild(cascade);
  252.  
  253.  
  254.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  255.   XtSetArg(args[0], XmNset, cb_demo_mode); argcount = 1;
  256.   button = XmCreateToggleButton(menu_pane, "Demo Mode", args, 1);
  257.   XtManageChild(button);
  258.   XtAddCallback(button, XmNvalueChangedCallback,
  259.         (XtCallbackProc)demo_modeCB, (XtPointer)0);
  260.   button = XmCreatePushButton(menu_pane, "Reset viewer", NULL, 0);
  261.   XtManageChild(button);
  262.   XtAddCallback(button, XmNactivateCallback, 
  263.         (XtCallbackProc)resetViewerCB, NULL);
  264.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  265.   cascade = XmCreateCascadeButton(menu_bar, "Misc", args, 1);
  266.   XtManageChild(cascade);
  267.  
  268.  
  269.   argcount = 0;
  270.   XtSetArg(args[argcount], XmNmarginWidth, 0); argcount++;
  271.   XtSetArg(args[argcount], XmNmarginHeight, 0); argcount++;
  272.   XtSetArg(args[argcount], XmNshadowThickness, 1); argcount++;
  273.   XtSetArg(args[argcount], XmNshadowType, XmSHADOW_OUT); argcount++;
  274.   frame = XmCreateFrame(main_window, "frame", args, argcount);
  275.   XtManageChild(frame);
  276.  
  277.   argcount = 0;
  278.   vi = find_visual();
  279.   if (vi) {
  280.     XtSetArg(args[argcount], GLwNvisualInfo, vi); argcount++;
  281.   }
  282.   else {
  283.     XtSetArg(args[argcount], GLwNrgba, TRUE); argcount++;
  284.     XtSetArg(args[argcount], GLwNdepthSize, 1); argcount++;
  285.     XtSetArg(args[argcount], GLwNdoublebuffer, TRUE); argcount++;
  286.   }
  287.   XtSetArg(args[argcount], XmNbottomAttachment, XmATTACH_FORM); argcount++;
  288.   XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_FORM); argcount++;
  289.   XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM); argcount++;
  290.   XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM); argcount++;
  291.   glw = GLwCreateMDrawingArea(frame, "glwidget", args, argcount);
  292.   XtManageChild(glw);
  293.   XtAddCallback(glw, GLwNginitCallback, (XtCallbackProc)initCB, 0);
  294.   XtAddCallback(glw, GLwNexposeCallback, (XtCallbackProc)exposeCB, 0);
  295.   XtAddCallback(glw, GLwNresizeCallback, (XtCallbackProc)resizeCB, 0);
  296.   XtAddCallback(glw, GLwNinputCallback, (XtCallbackProc)inputCB, 0);
  297.  
  298.   return main_window;
  299. }
  300.  
  301. void main(int argc, char **argv)
  302. {
  303.   Widget app_shell;
  304.   Arg args[max_args];
  305.   int argcount;
  306.  
  307.   XtToolkitInitialize();
  308.   app_context = XtCreateApplicationContext();
  309.   display = XtOpenDisplay(app_context, NULL, argv[0],
  310.                           "XMdemos", NULL, 0, &argc, argv);
  311.   if (!display) {
  312.     XtWarning("Can't open display.");
  313.     exit(0);
  314.   }
  315.  
  316.   argcount = 0;
  317.   XtSetArg(args[argcount], XmNmaxAspectX, 1); argcount++;
  318.   XtSetArg(args[argcount], XmNmaxAspectY, 1); argcount++;
  319.   XtSetArg(args[argcount], XmNminAspectX, 1); argcount++;
  320.   XtSetArg(args[argcount], XmNminAspectY, 1); argcount++;
  321.   app_shell = 
  322.     XtAppCreateShell(argv[0], "XMdemos", applicationShellWidgetClass,
  323.                      display, args, argcount);
  324.   
  325.   create_widgets(app_shell);
  326.  
  327.   XtRealizeWidget(app_shell);
  328.  
  329.   XtAppMainLoop(app_context);
  330.   
  331. }
  332.